home *** CD-ROM | disk | FTP | other *** search
/ PD ROM 1 / PD ROM Volume I - Macintosh Software from BMUG (1988).iso / Programming / Programming Tools / XCMDs / SoundCapToRes.c < prev    next >
Encoding:
C/C++ Source or Header  |  1987-08-01  |  7.1 KB  |  311 lines  |  [TEXT/ttxt]
  1. /*
  2.     SoundCapToRes -- a HyperCard user-defined command to create a 
  3.     'snd ' resource from a SoundCap file.
  4.     ©Apple Computer, Inc. 1987
  5.     All Rights Reserved.
  6.  
  7.     To compile and link this file using Macintosh Programmer's Workshop,
  8.  
  9.     C -q2 -g -ga SoundCapToRes.c
  10.     link -sn Main=SoundCapToRes -sn STDIO=SoundCapToRes ∂
  11.         -sn INTENV=SoundCapToRes -rt XCMD=20 ∂
  12.         -m SOUNDCAPTORES SoundCapToRes.c.o ∂
  13.         "{CLibraries}"StdCLib.o  "{CLibraries}"CInterface.o ∂
  14.         -o SoundCapMover
  15.     
  16.     This link directive puts the XCMD in the stack "SoundCapMover".
  17.     Substitute the name of the stack you want it in.  To move XCMDs
  18.     between stacks, use ResEdit.  They can be in an individual stack,
  19.     the Home stack, the HyperCard application, or the System File.
  20.     Don't use SndCapToRes to install a sound in the current stack or 
  21.     the Home stack (they're already open and in use).
  22.     
  23.     (XCMD=0 for flash from Pascal, =5 for cFlash from C)
  24.     (XCMD=11 Panasonic, =12 Hitachi, =13 Phillips, =14 PioneerLDV6000,
  25.     =15 PioneerLVP4200, =20 SoundCapToRes)
  26. */
  27.  
  28.  
  29. /*
  30.  * Usage: Type a command into a Hypertalk script. (SoundCapToRes must be
  31.  *        installed as a XCMD using ResEdit, see above). 
  32.  *
  33.  *    SoundCapToRes ResName,SndFile,StackFile,BaseNote
  34.  *    SoundCapToRes "Flute","Flute.cap",Sounds,60
  35.  *
  36.  *  By Steve Milne and Ted Kaehler.  DO NOT call the authors!
  37.  *  Contact Apple Developer Support on AppleLink "MacDst"
  38.  *  or on MCI "MacTech".
  39.  *
  40.  */
  41.  
  42. #include <Types.h>
  43. #include <StdIO.h>
  44. #include <Resources.h>
  45. #include <Memory.h>
  46. #include <OSUtils.h>
  47. #include <SM.h>
  48. #include <HyperXCmd.h>
  49.  
  50.  
  51. typedef struct SoundRes {
  52.     short                format;
  53.     short                refct;
  54.     short                numCommands;
  55.     SndCommand            command1;    /* add more lines like this for 
  56.                                     more commands */
  57.     SoundHeader            header;
  58.     char                data[0];    
  59. } SoundRes;
  60.  
  61. pascal    void    Debugger()    extern 0xA9FF;
  62.  
  63.     
  64. pascal void SoundCapToRes(paramPtr)
  65.     XCmdBlockPtr    paramPtr;
  66. {
  67.     char *    ResName;
  68.     char *    SourceFileName;
  69.     char *    DestFileName;
  70.     short    resRefNum;
  71.     short    baseNote;
  72.     Handle    theData,
  73.             ConstructRes ();
  74.     short    resID;
  75.     short    refNum;
  76.     long    ticks;
  77.     Str255    str;
  78.     
  79.     
  80.     if (paramPtr->paramCount < 3) return; /* baseNote is optional */
  81.     ResName = *(paramPtr->params[0]);
  82.     SourceFileName = *(paramPtr->params[1]);
  83.     DestFileName = *(paramPtr->params[2]);
  84.     if (paramPtr->paramCount >= 4)
  85.     {
  86.         /* 4th param is baseNote.  Convert it to a pascal string */
  87.         ZeroToPas(paramPtr,*(paramPtr->params[3]),&str);
  88.         /* Convert the string to a number */
  89.         baseNote = StrToNum(paramPtr,&str);
  90.     }
  91.     else
  92.     {
  93.         baseNote = 60;  /* default is middle C, natural pitch */
  94.     }
  95.  
  96.     
  97.     /* Open the sound file. */
  98.     if (FSOpen(SourceFileName,0,&refNum) != noErr)
  99.     {
  100.         /* Cannot open soundCap input file */
  101.         SysBeep(10);
  102.         Delay(3, &ticks);
  103.         SysBeep(10);
  104.         /* return an error message */
  105.         return;
  106.     }
  107.     
  108.     
  109.     /* Open the resource file.  If it doesn't exist, create it and
  110.      * open it.  */
  111.     if ( (resRefNum = OpenResFile (DestFileName)) == -1 )
  112.     {
  113.         CreateResFile (DestFileName);
  114.         if ( ResError() != noErr )
  115.         {
  116.             /* Cannot create resource file: */
  117.             return;
  118.         }
  119.         else if (resRefNum = OpenResFile (DestFileName) == -1 )
  120.         {
  121.             /* Cannot open created resource file (change iths later to replace) */
  122.             return;
  123.         }
  124.     }
  125.     
  126.     
  127.     /*   Check the baseNote    */
  128.     if ( (baseNote < 1) || (baseNote > 120) )
  129.     {
  130.         /* baseNote is out of range */
  131.         return;
  132.     }
  133.  
  134.     
  135.     /*
  136.      * See if the resource ID is unique.  If not create it.
  137.      * remove the old resource, if any 
  138.      */
  139.     
  140.     resID = GetNameAndID (resRefNum, ResName);
  141.     
  142.     /*
  143.      * Construct the resource.
  144.      */
  145.     if ( (theData = ConstructRes (refNum, baseNote, resID)) != nil )
  146.         AddRes (theData, resID, ResName);
  147.         
  148.     /*
  149.      * Close the sound file and resource file.
  150.      */
  151.     FSClose (refNum);
  152.     CloseResFile (resRefNum);
  153.     
  154.     /*
  155.      * Dispose of the handle.
  156.      */
  157.     if ( theData ) DisposHandle (theData);
  158.  
  159.     return;
  160. }
  161.  
  162.     
  163.  
  164. /* GetNameAndID
  165.  * See if the resource name is already in use.  If it is, delete it
  166.  * and we will create a new one in AddRes.  Get a new random
  167.  * resource ID if no resource of that name existed.
  168.  */
  169.     
  170. GetNameAndID (resRefNum, resName)
  171. short    resRefNum;
  172. char    * resName;
  173. {
  174.     short    resID;
  175.     Handle    dummy;
  176.     ResType    snd_Type;
  177.     Boolean    foundName;
  178.     
  179.     snd_Type = 'snd ';
  180.     SetResLoad (false);    /* prevent the resource from being loaded */
  181.     dummy = GetNamedResource(snd_Type, resName);    /* look for it by name */
  182.     foundName = (dummy != nil);        /* its there already */
  183.     /* make sure its in exactly the file, not up the chain */
  184.     if (foundName) foundName = ( HomeResFile(dummy) == resRefNum );
  185.     if (foundName)
  186.     {
  187.         /* get rid of the existing resource with the same name */
  188.         GetResInfo(dummy, &resID, &snd_Type, resName);    /* set resID */
  189.         RmveResource(dummy);
  190.     }
  191.     else
  192.     {    
  193.         /* assign a new random ID */
  194.         resID = UniqueID(snd_Type);
  195.     }
  196.     SetResLoad (true);    /* allow loading again */
  197.     return resID;
  198. }
  199.  
  200.  
  201. /*
  202.  * Construct the resource and write it out to the resource file.
  203.  */
  204. Handle
  205. ConstructRes (refNum, baseNote, resID)
  206. short    refNum;
  207. short    baseNote;
  208. short    resID;
  209. {
  210.     long        length;
  211.     SoundRes    *sndResPtr;
  212.     Handle        theData;
  213.     char        *pointer;
  214.     Boolean        NoSynth;
  215.  
  216.     /*
  217.      * Figure out how long the source file is.  This is the number of
  218.      * samples of sound.
  219.      */
  220.     
  221.     if  (GetEOF(refNum, &length) != noErr) 
  222.     {
  223.         /* can't read end of file */
  224.         return nil;
  225.     }
  226.  
  227.     /*
  228.      * Allocate a handle for the resource.
  229.      */
  230.     if ( (theData = NewHandle ( sizeof (SoundRes) + length )) == nil )
  231.     {
  232.         /* Not enough memory */
  233.         return nil;
  234.     }
  235.     HLock(theData);
  236.     
  237.     /*
  238.      * Fill in the resource information.
  239.      */
  240.     /* Format 2 'snd ' resurces assume that the application is using the
  241.     sampled synthesizer (snth=5).  Space is provided for the application
  242.     to do reference counting on the resource.  sndCapToRes does not put
  243.     any notes in (by itself, this sound installs an instrument but is 
  244.     silent.  The Play command in HyperTalk will supply the notes. */
  245.     
  246.     sndResPtr = *theData;
  247.     
  248.     sndResPtr->format                 = 2;    /* Format 2 */
  249.     sndResPtr->refct                 = 0;    /* space for reference count */
  250.     sndResPtr->numCommands             = 1;
  251.  
  252.     sndResPtr->command1.commandNum    = SoundCmd + DataPointerFlag;
  253.     sndResPtr->command1.wordArg    = 0;
  254.     sndResPtr->command1.longArg        = sizeof (SoundRes) - sizeof (SoundHeader);
  255.     
  256.     sndResPtr->header.samplePtr        = 0;
  257.     sndResPtr->header.length        = length;
  258.     sndResPtr->header.sampleRate    = 0x56EE8BA4;    /* sampling rate 22Khz */
  259.     sndResPtr->header.loopStart        = length - 2;
  260.     sndResPtr->header.loopEnd        = length - 1;
  261.     sndResPtr->header.baseNote        = baseNote;
  262.     
  263.     /*
  264.      * Copy the data from the source file to the end of the resource.
  265.      */
  266.     pointer = sndResPtr->data;
  267.     FSRead(refNum, &length, pointer);
  268.     
  269.     HUnlock(theData);
  270.     
  271.     return theData;
  272. }
  273.  
  274. /*
  275.  * Add and write out a resource.
  276.  */
  277.  
  278. AddRes (theData, resID, resName)
  279.     Handle    theData;
  280.     short    resID;
  281.     char    *resName;
  282. {
  283.     ResType    snd_Type;
  284.  
  285.     /*
  286.      * Add the resource to the file and write it out.
  287.      */
  288.     snd_Type = 'snd ';
  289.     AddResource (theData, snd_Type, resID, resName);
  290.     if ( ResError() != noErr )
  291.     {
  292.         /* Cannot add the resource. */
  293.         return -1;
  294.     }
  295.     
  296.     /*  Make the 'snd ' resource purgable  */
  297.     SetResAttrs(theData,(GetResAttrs(theData) | 0x20));
  298.     
  299.     WriteResource (theData);
  300.     if ( ResError() != noErr )
  301.     {
  302.         /* Cannot write the resource. */
  303.         return -1;
  304.     }
  305.     
  306.     return 0;
  307. }
  308.  
  309. /* C routines for HyperCard callbacks */
  310. #include <XCmdGlue.inc.c>
  311.